C++ Primer, Fifth Edition: Managing Container Growth: Size vs. Capacity

In C++, managing container growth is an architectural dance between Size (current elements) and Capacity (reserved memory). For contiguous containers like vector and string, reaching capacity triggers a reallocation: the system finds a larger memory block, moves all elements, and destroys the old block. This is a costly $O(n)$ operation that causes iterator invalidation—your pointers to old elements become "dangling" and dangerous.

1. Expansion Strategy

To avoid frequent reallocations, vector implementations allocate "buffer" space. The c.reserve(n) command explicitly sets a minimum capacity without adding elements, while c.shrink_to_fit() is a non-binding request to return excess memory to the OS.

2. The Resize vs. Reserve Distinction

While reserve only affects the buffer, resize(n) actively changes the container's logic. Shrinking via resize destroys elements, while expanding adds default-initialized values.

⚠️ WARNING: If resize shrinks the container, iterators to deleted elements are invalidated. If expansion causes reallocation, ALL iterators are invalidated.

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

Exercise 9.34: Predict the behavior of this loop: while (iter != vi.end()) { if (*iter % 2) iter = vi.insert(iter, *iter); ++iter; }

It duplicates all odd numbers once and finishes.

It results in an infinite loop if an odd number is found.

It skips all odd numbers.

It causes a compilation error because of iterator types.

QUESTION 2

Exercise 10.10: Why don't generic algorithms like find or sort change the size of containers?

They operate on iterators, which provide no interface to add/remove container memory.

Changing size would be too slow for generic code.

The C++ standard forbids algorithms from using memory.

Algorithms only work on fixed-size arrays.

QUESTION 3

Given vec has 25 elements, what happens if we call vec.resize(100) then vec.resize(10)?

Size becomes 100, then drops to 10; capacity likely stays at 100 throughout.

Size becomes 100, then 10; capacity drops to 10 immediately.

The program crashes on the second resize.

The elements from index 10-99 are moved to a temporary buffer.

QUESTION 4

What restriction is placed on the element type when calling the single-argument version of resize?

It must be a primitive type (int, double, etc.).

It must have a default constructor.

It must have a copy constructor.

It cannot be a const type.

QUESTION 5

Exercise 10.39: What kind of iterator does a list have versus a vector?

List: Forward; Vector: Random-access

List: Bidirectional; Vector: Random-access

Both have Random-access iterators.

List: Output; Vector: Input

Case Study: Safe Iterator Loops

Managing Growth in Real-time Applications

You are processing a vector of integers. For every odd number, you must duplicate it. You also need to maintain efficiency and avoid segmentation faults caused by container reallocation during the loop.

1. Re-implement Exercise 9.34 correctly to avoid the infinite loop and handle iterator invalidation.

Solution:
To fix the loop: iter = vi.begin(); while (iter != vi.end()) { if (*iter % 2) { iter = vi.insert(iter, *iter); iter += 2; } else { ++iter; } } This works because insert returns the iterator to the new element; we advance past both the new and original elements to find the next candidate.

2. Rewrite the duplicate word elimination logic from § 10.2.3 to use a list instead of a vector. What changes?

Solution:
Since list does not support random-access, we cannot use generic sort. We must use lst.sort() and lst.unique() member functions. Unlike the vector version, lst.unique() actually removes elements from the list, changing its size immediately without needing a separate erase call.

3. Exercise 10.19: Rewrite the biggies logic to use stable_partition instead of find_if to maintain original order.

Solution:
auto wc = stable_partition(words.begin(), words.end(), [sz](const string &s) { return s.size() >= sz; }); This reorders the container such that all elements meeting the criteria come first, returning an iterator to the first element that does NOT meet the criteria.